home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 351-375 / 371 / fractals / src / formulas.c < prev    next >
C/C++ Source or Header  |  1995-03-14  |  43KB  |  1,916 lines
  1. /* formulas.c */
  2. #define Ult_Zmax lim1
  3. #define Ult_dZmin lim4
  4. #define Ult_Zremax lim2
  5. #define Ult_Zimmax lim3
  6. #include <stdio.h>
  7. #include <math.h>
  8. #include <exec/types.h>
  9. #include <intuition/intuition.h>
  10. #include "defs.h"
  11.  
  12.  
  13. extern float remin;
  14. extern char reminbuf[];
  15. extern float remax;
  16. extern char remaxbuf[];
  17. extern float immin;
  18. extern char imminbuf[];
  19. extern float immax;
  20. extern char immaxbuf[];
  21. extern float reconst;
  22. extern char reconstbuf[];
  23. extern float imconst;
  24. extern char imconstbuf[];
  25. extern float magre;
  26. extern char magrebuf[];
  27. extern float magim;
  28. extern char magimbuf[];
  29. extern float re0const;
  30. extern char re0constbuf[];
  31. extern float im0const;
  32. extern char im0constbuf[];
  33. extern float re1const;
  34. extern char re1constbuf[];
  35. extern float im1const;
  36. extern char im1constbuf[];
  37. extern float re2const;
  38. extern char re2constbuf[];
  39. extern float im2const;
  40. extern char im2constbuf[];
  41. extern float re3const;
  42. extern char re3constbuf[];
  43. extern float im3const;
  44. extern char im3constbuf[];
  45. extern float re4const;
  46. extern char re4constbuf[];
  47. extern float im4const;
  48. extern char im4constbuf[];
  49. extern float re5const;
  50. extern char re5constbuf[];
  51. extern float im5const;
  52. extern char im5constbuf[];
  53. extern float re6const;
  54. extern char re6constbuf[];
  55. extern float im6const;
  56. extern char im6constbuf[];
  57. extern float re7const;
  58. extern char re7constbuf[];
  59. extern float im7const;
  60. extern char im7constbuf[];
  61. extern float re8const;
  62. extern char re8constbuf[];
  63. extern float im8const;
  64. extern char im8constbuf[];
  65. extern float re9const;
  66. extern char re9constbuf[];
  67. extern float im9const;
  68. extern char im9constbuf[];
  69. extern float lim1;
  70. extern char lim1buf[];
  71. extern float lim2;
  72. extern char lim2buf[];
  73. extern float lim3;
  74. extern char lim3buf[];
  75. extern float lim4;
  76. extern char lim4buf[];
  77.  
  78. extern float lambda;
  79. extern char lambdabuf[];
  80. extern float lamexp;
  81. extern char lamexpbuf[];
  82. extern float epsilon;
  83. extern char epsilonbuf[];
  84. extern short maxiter;
  85. extern char maxiterbuf[];
  86. extern float bioreconst;
  87. extern char biorebuf[];
  88. extern float bioimconst;
  89. extern char bioimbuf[];
  90. extern float heightconst;
  91. extern char hcbuf[];
  92. extern short radius;
  93. extern char radiusbuf[];
  94. extern short step;
  95. extern char stepbuf[];
  96. extern short rulelen;
  97. extern char rulebuf[];
  98.  
  99. extern struct Gadget gad[];
  100. extern struct Gadget gadb[];
  101. extern struct Screen *scr,*openscreen(),*OpenScreen();
  102. extern struct Window *gwdw,*wdw,*openwindow(),*OpenWindow();
  103. extern struct Menu men[];
  104. extern long titelflag;
  105.  
  106. extern struct IntuitionBase *IntuitionBase;
  107. extern struct GfxBase *GfxBase;
  108. extern struct RastPort *rport;
  109. extern short tmpcol,mennum,itmnum,subnum;
  110. extern short width;
  111. extern short height;
  112. extern short depth;
  113.  
  114. struct Message *GetMsg();
  115. struct IntuiMessage *imsg;
  116. struct View *ViewPortAddress();
  117. struct ViewPort *WVP;
  118. long Text(),Wait();
  119. void Move(),ReplyMsg(),CloseWindow(),ShowTitle();
  120. void ColorWindow(),SetAPen(),WritePixel(),scanmenu(),SetRGB4();
  121. void Draw(),RectFill(),SetMenuStrip(),ClearMenuStrip();
  122. void PutBoolGadget(),PutGadget();
  123. short GetRGB4();
  124. void prepult(),runfractal();
  125. void toggletitle(),ShowTitle();
  126.  
  127. static short biomorph=BIO0;
  128. static short newton=NR0;
  129. extern short surface;
  130. static short fractal=LCOSZ;
  131. static short counter;
  132. extern short xc,yc,xoffset,yoffset;
  133. static float resave,imsave,restep,imstep;
  134. static float re,re2,im,im2,tmp,lambdahalva;
  135.  
  136.  
  137. double sqrt(),atan(),log(),atof(),exp(),sin(),cos(),fabs();
  138.  
  139. void getfractal(),getvalues();
  140. void magnet0(),magnet1(),magnet2(),magnet3();
  141. void mandelbrot(),julia(),ultimate(),lcosz(),esinz(),lexpz();
  142. void bio0(),bio1(),bio2(),bio3(),bio4(),bio5();
  143. void nr0(),nr1(),nr2(),nr3(),nr4(),nr5();
  144. void runfractal(),frac1(),frac2(),frac3();
  145. void (*fracalg)()=lcosz;
  146.  
  147.  
  148. void Ult_A(),Ult_B(),Ult_C(),Ult_D(),Ult_E(),Ult_F(),Ult_G(),Ult_H();
  149. void Ult_I(),Ult_J(),Ult_K(),Ult_L(),Ult_M(),Ult_N(),Ult_O(),Ult_P();
  150. void Ult_Q(),Ult_R(),Ult_S(),Ult_T();
  151. void Ult_a(),Ult_b(),Ult_c(),Ult_d(),Ult_e(),Ult_f(),Ult_g(),Ult_h();
  152. void Ult_i(),Ult_j(),Ult_k(),Ult_l(),Ult_m(),Ult_n(),Ult_o(),Ult_p();
  153. void Ult_q(),Ult_r(),Ult_s(),Ult_t();
  154. void Ult_swplo(),Ult_swphi(),Ult_mmlo(),Ult_plo();
  155. float Ult_Z0re,Ult_Z0im,Ult_Znre,Ult_Znim;
  156. float Ult_re,Ult_im;
  157. float Ult_tmpre[12],Ult_tmpim[12];
  158. float Ult_cre[10],Ult_cim[10];
  159. short Ult_cnt,Ult_brk;
  160.  
  161.  
  162. void lcosz()
  163. {
  164. register float rereg,imreg,tmpreg,lambdahalvareg;
  165.  
  166. lambdahalvareg=lambdahalva;
  167. imreg=imsave;
  168. rereg=resave;
  169. for(counter=0;counter<maxiter;counter++)
  170.    {
  171.     tmpreg=exp(-imreg);
  172.     im2=imreg=tmpreg*sin(rereg);
  173.     re2=rereg=tmpreg*cos(rereg);
  174.     if((fabs(imreg) > 1e9)||(fabs(rereg) > 1e9))
  175.       { counter=maxiter;  }
  176.     else
  177.        tmpreg=rereg*rereg+imreg*imreg;
  178.     if( tmpreg==0 )tmpreg=0.0000000000001;
  179.     rereg=rereg/tmpreg;
  180.     imreg=-imreg/tmpreg;
  181.     rereg=(rereg+re2)*lambdahalvareg;
  182.     imreg=(imreg+im2)*lambdahalvareg;
  183.     if( fabs(imreg) > 19 )
  184.        return();
  185.    };
  186. }
  187.  
  188.  
  189. void bio0()
  190. {
  191. register float rereg,imreg,re2reg,im2reg;
  192. float tmp;
  193. short coltmp;
  194.  
  195. imreg=imsave;
  196. rereg=resave;
  197. re2reg=rereg*rereg;
  198. im2reg=imreg*imreg;
  199. for(counter=0;counter<maxiter;counter++)
  200.    {
  201.     tmp  =rereg*(re2reg-3*im2reg)+bioreconst;
  202.     imreg=imreg*(3*re2reg-im2reg)+bioimconst;
  203.     rereg=tmp;
  204.     re2reg=rereg*rereg;
  205.     im2reg=imreg*imreg;
  206.     if( (fabs(imreg) > 10) || (fabs(rereg) > 10) || (fabs(re2reg+im2reg) >100 ) )
  207.        {
  208.         coltmp=
  209.            (fabs(rereg)<10)?2:0;
  210.  
  211.         if(fabs(imreg)<10)coltmp++;
  212.  
  213.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  214.  
  215.         return();
  216.        };
  217.    };
  218. }
  219.  
  220. void bio1()
  221. {
  222. register float rereg,imreg,re2reg,im2reg;
  223. float bel,arg;
  224. short coltmp;
  225.  
  226. imreg=imsave;
  227. rereg=resave;
  228. re2reg=rereg*rereg;
  229. im2reg=imreg*imreg;
  230. for(counter=0;counter<maxiter;counter++)
  231.    {
  232.     bel=sqrt((double)(re2reg+im2reg));
  233.     if(rereg>0)arg=atan((double)(imreg/rereg));
  234.     else if(rereg<0)arg=-3.1415+atan((double)(imreg/rereg));
  235.     else if(imreg>0)arg=1.5708;
  236.     else arg=-1.5708;
  237.     arg*=5;
  238.     bel=bel*bel*bel*bel*bel;
  239.     rereg=bel*cos((double)arg)+bioreconst;
  240.     imreg=bel*sin((double)arg)+bioimconst;
  241.     re2reg=rereg*rereg;
  242.     im2reg=imreg*imreg;
  243.     if( fabs(re2reg+im2reg) > 100 )
  244.        {
  245.         coltmp=
  246.            (fabs(rereg)<10)?2:0;
  247.  
  248.         if(fabs(imreg)<10)coltmp++;
  249.  
  250.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  251.  
  252.         return();
  253.        };
  254.    };
  255. }
  256.  
  257.  
  258. void bio2()
  259. {
  260. register float rereg,imreg,re2reg,im2reg;
  261. float bel,arg;
  262. float lnbel,zzbel,zzarg,zzre,zzim;
  263. float z5bel,z5arg,z5re,z5im;
  264. short coltmp;
  265.  
  266. imreg=imsave;
  267. rereg=resave;
  268. re2reg=rereg*rereg;
  269. im2reg=imreg*imreg;
  270. for(counter=0;counter<maxiter;counter++)
  271.    {
  272.     bel=sqrt((double)(re2reg+im2reg));
  273.     if(rereg>0)arg=atan((double)(imreg/rereg));
  274.     else if((rereg<0)&&(imreg>0))arg= 3.1415+atan((double)(imreg/rereg));
  275.     else if((rereg<0)&&(imreg<0))arg= -3.1415+atan((double)(imreg/rereg));
  276.     else if(imreg>0)arg=1.5708;
  277.     else arg=-1.5708;
  278.  
  279.     lnbel=log((double)bel);
  280.     zzbel=exp((double)(rereg*lnbel-imreg*arg));
  281.     zzarg=rereg*fabs((double)arg)+fabs((double)imreg)*lnbel;
  282.     zzre=zzbel*cos((double)zzarg);
  283.     zzim=zzbel*sin((double)zzarg);
  284.  
  285.     z5bel=bel*bel*bel*bel*bel;
  286.     z5arg=5*arg;
  287.     z5re=z5bel*cos((double)z5arg);
  288.     z5im=z5bel*sin((double)z5arg);
  289.  
  290.     rereg=zzre+z5re+bioreconst;
  291.     imreg=zzim+z5im+bioimconst;
  292.  
  293.     re2reg=rereg*rereg;
  294.     im2reg=imreg*imreg;
  295.     if( fabs(re2reg+im2reg) > 100 )
  296.        {
  297.         coltmp=
  298.            (fabs(rereg)<10)?2:0;
  299.  
  300.         if(fabs(imreg)<10)coltmp++;
  301.  
  302.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  303.  
  304.         return();
  305.        };
  306.    };
  307. }
  308.  
  309. void bio3()
  310. {
  311. register float rereg,imreg,re2reg,im2reg;
  312. float bel,arg;
  313. float lnbel,zzbel,zzarg,zzre,zzim;
  314. float z6bel,z6arg,z6re,z6im;
  315. short coltmp;
  316.  
  317. imreg=imsave;
  318. rereg=resave;
  319. re2reg=rereg*rereg;
  320. im2reg=imreg*imreg;
  321. for(counter=0;counter<maxiter;counter++)
  322.    {
  323.     bel=sqrt((double)(re2reg+im2reg));
  324.     if(rereg>0)arg=atan((double)(imreg/rereg));
  325.     else if((rereg<0)&&(imreg>0))arg= 3.1415+atan((double)(imreg/rereg));
  326.     else if((rereg<0)&&(imreg<0))arg= -3.1415+atan((double)(imreg/rereg));
  327.     else if(imreg>0)arg=1.5708;
  328.     else arg=-1.5708;
  329.  
  330.     lnbel=log((double)bel);
  331.     zzbel=exp((double)(rereg*lnbel-imreg*arg));
  332.     zzarg=rereg*fabs((double)arg)+fabs((double)imreg)*lnbel;
  333.     zzre=zzbel*cos((double)zzarg);
  334.     zzim=zzbel*sin((double)zzarg);
  335.  
  336.     z6bel=bel*bel*bel*bel*bel*bel;
  337.     z6arg=6*arg;
  338.     z6re=z6bel*cos((double)z6arg);
  339.     z6im=z6bel*sin((double)z6arg);
  340.  
  341.     rereg=zzre+z6re+bioreconst;
  342.     imreg=zzim+z6im+bioimconst;
  343.  
  344.     re2reg=rereg*rereg;
  345.     im2reg=imreg*imreg;
  346.     if( fabs(re2reg+im2reg) > 100 )
  347.        {
  348.         coltmp=
  349.            (fabs(rereg)<10)?2:0;
  350.  
  351.         if(fabs(imreg)<10)coltmp++;
  352.  
  353.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  354.  
  355.         return();
  356.        };
  357.    };
  358. }
  359.  
  360.  
  361. void bio4()
  362. {
  363. register float sinre,sinim,sinre2,sinim2;
  364.  
  365. float sintmp,rereg,re2reg,imreg,im2reg;
  366. short coltmp;
  367.  
  368. imreg=imsave;
  369. rereg=resave;
  370. re2reg=rereg*rereg;
  371. im2reg=imreg*imreg;
  372. for(counter=0;counter<maxiter;counter++)
  373.    {
  374.     sintmp=exp(-imreg);
  375.     sinim2=sinim=sintmp*sin(rereg);
  376.     sinre2=sinre=sintmp*cos(rereg);
  377.     sintmp=sinre*sinre+sinim*sinim;
  378.     if( sintmp==0 )sintmp=0.0000000000001;
  379.     sinre=sinre/sintmp;
  380.     sinim=-sinim/sintmp;
  381.     sintmp=(sinim-sinim2)/2;
  382.     sinim=-(sinre-sinre2)/2;
  383.     sinre=sintmp;
  384.     sintmp=sinre-sinim;
  385.     sinim=sinim+sinre;
  386.     sinre=sintmp;
  387.  
  388.     sintmp=sinre+re2reg-im2reg+bioreconst;
  389.     imreg =sinim+2*rereg*imreg+bioimconst;
  390.     rereg=sintmp;
  391.  
  392.     re2reg=rereg*rereg;
  393.     im2reg=imreg*imreg;
  394.     if( fabs(re2reg+im2reg) > 100 )
  395.        {
  396.         coltmp=
  397.            (fabs(rereg)<10)?2:0;
  398.  
  399.         if(fabs(imreg)<10)coltmp++;
  400.  
  401.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  402.  
  403.         return();
  404.        };
  405.    };
  406. }
  407.  
  408. void bio5()
  409. {
  410. register float sinre,sinim,sinre2,sinim2;
  411. float expre,expim;
  412. float sintmp,rereg,re2reg,imreg,im2reg;
  413. short coltmp;
  414.  
  415. imreg=imsave;
  416. rereg=resave;
  417. re2reg=rereg*rereg;
  418. im2reg=imreg*imreg;
  419. for(counter=0;counter<maxiter;counter++)
  420.    {
  421.     sintmp=exp(-imreg);
  422.     sinim2=sinim=sintmp*sin(rereg);
  423.     sinre2=sinre=sintmp*cos(rereg);
  424.     sintmp=sinre*sinre+sinim*sinim;
  425.     if( sintmp==0 )sintmp=0.0000000000001;
  426.     sinre=sinre/sintmp;
  427.     sinim=-sinim/sintmp;
  428.     sintmp=(sinim-sinim2)/2;
  429.     sinim=-(sinre-sinre2)/2;
  430.     sinre=sintmp;
  431.     sintmp=sinre-sinim;
  432.     sinim=sinim+sinre;
  433.     sinre=sintmp;
  434.  
  435.     sintmp=exp(rereg);
  436.     expre=sintmp*cos(imreg);
  437.     expim=sintmp*sin(imreg);
  438.  
  439.     sintmp=sinre+expre+bioreconst;
  440.     imreg =sinim+expim+bioimconst;
  441.     rereg=sintmp;
  442.  
  443.     re2reg=rereg*rereg;
  444.     im2reg=imreg*imreg;
  445.     if( fabs(re2reg+im2reg) > 100 )
  446.        {
  447.         coltmp=
  448.            (fabs(rereg)<10)?2:0;
  449.  
  450.         if(fabs(imreg)<10)coltmp++;
  451.  
  452.         (coltmp!=0)? (counter+=coltmp):(counter=maxiter);
  453.  
  454.         return();
  455.        };
  456.    };
  457. }
  458.  
  459.  
  460. void lexpz()
  461. {
  462. register float rereg,imreg,tmpreg;
  463.  
  464. imreg=imsave;
  465. rereg=resave;
  466. for(counter=0;counter<maxiter;counter++)
  467.    {
  468.     tmpreg=exp(rereg)*lamexp;
  469.     rereg=tmpreg*cos(imreg);
  470.     imreg=tmpreg*sin(imreg);
  471.     if( fabs(rereg) > 30 )
  472.        return();
  473.    };
  474. }
  475.  
  476. void esinz()
  477. {
  478. register float rereg,imreg,tmpreg,lambdahalvareg;
  479.  
  480. imreg=imsave;
  481. rereg=resave;
  482. for(counter=0;counter<maxiter;counter++)
  483.    {
  484.     tmpreg=exp(-imreg);
  485.     im2=imreg=tmpreg*sin(rereg);
  486.     re2=rereg=tmpreg*cos(rereg);
  487.     if((fabs(imreg) > 1e9)||(fabs(rereg) > 1e9))
  488.       { counter=maxiter;  }
  489.     else
  490.        tmpreg=rereg*rereg+imreg*imreg;
  491.     if( tmpreg==0 )tmpreg=0.0000000000001;
  492.     rereg=rereg/tmpreg;
  493.     imreg=-imreg/tmpreg;
  494.     tmpreg=(imreg-im2)/2;
  495.     imreg=-(rereg-re2)/2;
  496.     rereg=tmpreg;
  497.     tmpreg=rereg-imreg*epsilon;
  498.     imreg=imreg+rereg*epsilon;
  499.     rereg=tmpreg;
  500.     if( fabs(imreg) > 19 )
  501.        return();
  502.    };
  503. }
  504.  
  505. void mandelbrot()
  506. {
  507. register float rereg,imreg,tmpreg,absreg;
  508. float tmp;
  509.  
  510. rereg=imreg=absreg=0;
  511. for(counter=0;counter<maxiter;counter++)
  512.    {
  513.    tmp=imreg*imreg;
  514.    absreg=rereg*rereg;
  515.    tmpreg=absreg-tmp+resave;
  516.    imreg=2*rereg*imreg+imsave;
  517.    rereg=tmpreg;
  518.    absreg+=tmp;
  519.    if( fabs(absreg) > 4 )
  520.        return();
  521.    };
  522. }
  523.  
  524. void julia()
  525. {
  526. register float rereg,imreg,tmpreg,absreg;
  527. float tmp;
  528.  
  529. rereg=resave;
  530. imreg=imsave;
  531. for(counter=0;counter<maxiter;counter++)
  532.    {
  533.    tmp=imreg*imreg;
  534.    absreg=rereg*rereg;
  535.    tmpreg=absreg-tmp+reconst;
  536.    imreg=2*rereg*imreg+imconst;
  537.    rereg=tmpreg;
  538.    absreg+=tmp;
  539.    if( fabs(absreg) > 4 )
  540.        return();
  541.    };
  542.  
  543. }
  544.  
  545.  
  546. void nr0()
  547. {
  548. register float rereg,imreg,re2,im2;
  549. float re,im,reim,ret,imt,ren,imn,tmp;
  550.  
  551. imreg=imsave;
  552. rereg=resave;
  553. re2=rereg*rereg;
  554. im2=imreg*imreg;
  555. reim=3*rereg*imreg;
  556. for(counter=0;counter<maxiter;counter++)
  557.    {
  558.     re=re2*rereg-reim*imreg-1;
  559.     im=rereg*reim-im2*imreg;
  560.     ren=3*(re2-im2);
  561.     imn=2*reim;
  562.     ret=re*ren+im*imn;
  563.     imt=im*ren-re*imn;
  564.     tmp=ren*ren+imn*imn;if(tmp==0)tmp=0.00000001;
  565.     ret/=tmp;
  566.     imt/=tmp;
  567.     rereg-=ret;
  568.     imreg-=imt;
  569.     re2=rereg*rereg;
  570.     im2=imreg*imreg;
  571.     reim=3*rereg*imreg;
  572.     if(  ((fabs(rereg-1)<0.000001)  &&(fabs(imreg)<0.000001))
  573.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg-0.866025)<0.000001))
  574.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg+0.866025)<0.000001))  )
  575.          return();
  576.    };
  577. }
  578.  
  579.  
  580. void nr1()
  581. {
  582. register float rereg,imreg,z3re,z3im;
  583. float z4re,z4im;
  584. float tmp;
  585.  
  586. imreg=imsave;
  587. rereg=resave;
  588. for(counter=0;counter<maxiter;counter++)
  589.    {
  590.     z3re=rereg*rereg-imreg*imreg;
  591.     z3im=2*rereg*imreg;
  592.     z4re=3*(z3re*z3re-z3im*z3im)+1;
  593.     z4im=6*z3re*z3im;
  594.     tmp=z3re*rereg-z3im*imreg;
  595.     z3im=4*(z3re*imreg+z3im*rereg);
  596.     z3re=4*tmp;
  597.  
  598.     rereg=z3re*z3re+z3im*z3im;if(rereg==0)rereg=0.0000001;
  599.     imreg=(z4im*z3re-z4re*z3im)/rereg;
  600.     rereg=(z4re*z3re+z4im*z3im)/rereg;
  601.  
  602.     if(fabs((double)rereg)<0.00001)
  603.     if((fabs((double)imreg-1)<0.00001)||(fabs((double)imreg+1)<0.00001))
  604.        return();
  605.     if(fabs((double)imreg)<0.00001)
  606.     if((fabs((double)rereg-1)<0.00001)||(fabs((double)rereg+1)<0.00001))
  607.        return();
  608.    };
  609. }
  610.  
  611.  
  612. void nr2()
  613. {
  614. register float rereg,imreg,z4re,z4im;
  615. float z5re,z5im;
  616. float tmp;
  617.  
  618. imreg=imsave;
  619. rereg=resave;
  620. for(counter=0;counter<maxiter;counter++)
  621.    {
  622.     z4re=rereg*rereg-imreg*imreg;
  623.     z4im=2*rereg*imreg;
  624.     tmp=z4re*z4re-z4im*z4im;
  625.     z4im=2*z4re*z4im;
  626.     z4re=tmp;
  627.     z5re=4*(z4re*rereg-z4im*imreg)+1;
  628.     z5im=4*(z4re*imreg+z4im*rereg);
  629.  
  630.     z4re=5*z4re;
  631.     z4im=5*z4im;
  632.  
  633.     tmp=z4re*z4re+z4im*z4im;if(tmp==0)tmp=0.00000001;
  634.     rereg=(z5re*z4re+z5im*z4im)/tmp;
  635.     imreg=(z5im*z4re-z5re*z4im)/tmp;
  636.  
  637.     if( (fabs((double)rereg-1)<0.00001)
  638.       &&(fabs((double)imreg)<0.00001) )
  639.          return();
  640.     if( (fabs((double)rereg-0.3090170)<0.00001)
  641.       &&(fabs(fabs((double)imreg)-0.9510566)<0.00001))
  642.          return();
  643.     if( (fabs((double)rereg+0.8090170)<0.00001)
  644.       &&(fabs(fabs((double)imreg)-0.5877853)<0.00001))
  645.          return();
  646.    };
  647. }
  648.  
  649. void nr3()
  650. {
  651. register float rereg,imreg,z4re,z4im;
  652. float z2re,z2im,z5re,z5im;
  653. float tmp;
  654.  
  655. imreg=imsave;
  656. rereg=resave;
  657. for(counter=0;counter<maxiter;counter++)
  658.    {
  659.     z2re=z4re=rereg*rereg-imreg*imreg;
  660.     z2im=z4im=2*rereg*imreg;
  661.     tmp=z4re*z4re-z4im*z4im;
  662.     z4im=2*z4re*z4im;
  663.     z4re=tmp;
  664.     z5re=4*(z4re*rereg-z4im*imreg)+2*(z2re*rereg-z2im*imreg)+1;
  665.     z5im=4*(z4re*imreg+z4im*rereg)+2*(z2re*imreg+z2im*rereg);
  666.  
  667.     z4re=5*z4re+3*z2re;
  668.     z4im=5*z4im+3*z2im;
  669.  
  670.     tmp=z4re*z4re+z4im*z4im;if(tmp==0)tmp=0.00000001;
  671.     rereg=(z5re*z4re+z5im*z4im)/tmp;
  672.     imreg=(z5im*z4re-z5re*z4im)/tmp;
  673.  
  674.     if( (fabs((double)rereg-0.83761977)<0.00001)
  675.       &&(fabs((double)imreg)<0.00001))
  676.          return();
  677.     if( (fabs((double)rereg-0.21785321)<0.00001)
  678.       &&(fabs(fabs((double)imreg)-1.1669512)<0.00001))
  679.          return();
  680.     if( (fabs((double)rereg+0.6366631)<0.00001)
  681.       &&(fabs(fabs((double)imreg)-0.6647016)<0.00001))
  682.          return();
  683.    };
  684. }
  685.  
  686.  
  687. void nr4()
  688. {
  689. register float rereg,imreg,re2,im2;
  690. float re,im,reim,ret,imt,ren,imn,tmp;
  691. short coltmp;
  692.  
  693. imreg=imsave;
  694. rereg=resave;
  695. re2=rereg*rereg;
  696. im2=imreg*imreg;
  697. reim=3*rereg*imreg;
  698. for(counter=0;counter<maxiter;counter++)
  699.    {
  700.     re=re2*rereg-reim*imreg-1;
  701.     im=rereg*reim-im2*imreg;
  702.     ren=3*(re2-im2);
  703.     imn=2*reim;
  704.     ret=re*ren+im*imn;
  705.     imt=im*ren-re*imn;
  706.     tmp=ren*ren+imn*imn;if(tmp==0)tmp=0.00000001;
  707.     ret/=tmp;
  708.     imt/=tmp;
  709.     rereg-=ret;
  710.     imreg-=imt;
  711.     re2=rereg*rereg;
  712.     im2=imreg*imreg;
  713.     reim=3*rereg*imreg;
  714.     if(  ((fabs(rereg-1)<0.000001)  &&(fabs(imreg)<0.000001))
  715.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg-0.866025)<0.000001))
  716.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg+0.866025)<0.000001))  )
  717.          return();
  718.    };
  719. }
  720.  
  721.  
  722. void nr5()
  723. {
  724. register float rereg,imreg,re2,im2;
  725. float re,im,reim,ret,imt,ren,imn,tmp;
  726. short coltmp;
  727.  
  728. imreg=imsave;
  729. rereg=resave;
  730. re2=rereg*rereg;
  731. im2=imreg*imreg;
  732. reim=3*rereg*imreg;
  733. for(counter=0;counter<maxiter;counter++)
  734.    {
  735.     re=re2*rereg-reim*imreg-1;
  736.     im=rereg*reim-im2*imreg;
  737.     ren=3*(re2-im2);
  738.     imn=2*reim;
  739.     ret=re*ren+im*imn;
  740.     imt=im*ren-re*imn;
  741.     tmp=ren*ren+imn*imn;if(tmp==0)tmp=0.00000001;
  742.     ret/=tmp;
  743.     imt/=tmp;
  744.     rereg-=ret;
  745.     imreg-=imt;
  746.     re2=rereg*rereg;
  747.     im2=imreg*imreg;
  748.     reim=3*rereg*imreg;
  749.     if(  ((fabs(rereg-1)<0.000001)  &&(fabs(imreg)<0.000001))
  750.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg-0.866025)<0.000001))
  751.       || ((fabs(rereg+0.5)<0.000001)&&(fabs(imreg+0.866025)<0.000001))  )
  752.          return();
  753.    };
  754. }
  755.  
  756.  
  757. void magnet0()
  758. {
  759. register float rereg,imreg,tmpreg,absreg;
  760. float tmp,ret,imt,ren,imn;
  761.  
  762. rereg=resave;
  763. imreg=imsave;
  764. for(counter=0;counter<maxiter;counter++)
  765.    {
  766.     ret=rereg*rereg-imreg*imreg+magre-1;
  767.     imt=2*rereg*imreg+magim;
  768.     ren=2*rereg+magre-2;
  769.     imn=2*imreg+magim;
  770.     tmp=ren*ren+imn*imn;
  771.     if(fabs(tmp)<0.00001)tmp=0.00001;
  772.     rereg=(ret*ren+imt*imn)/tmp;
  773.     imreg=(ren*imt-ret*imn)/tmp;
  774.  
  775.     tmp=rereg*rereg-imreg*imreg;
  776.     imreg=2*rereg*imreg;
  777.     rereg=tmp;
  778.  
  779.     absreg=rereg*rereg+imreg*imreg;
  780.  
  781.    if( fabs(absreg) > 10000 )
  782.      { counter&=15;return(); };
  783.    if( (fabs(rereg-1)+fabs(imreg))<0.01 )
  784.      { counter&=15;counter|=16;return(); };
  785.    };
  786.  
  787. }
  788.  
  789.  
  790. void magnet1()
  791. {
  792. register float rereg,imreg,tmpreg,absreg;
  793. float tmp,ret,imt,ren,imn;
  794.  
  795. rereg=0;
  796. imreg=0;
  797. for(counter=0;counter<maxiter;counter++)
  798.    {
  799.     ret=rereg*rereg-imreg*imreg+resave-1;
  800.     imt=2*rereg*imreg+imsave;
  801.     ren=2*rereg+resave-2;
  802.     imn=2*imreg+imsave;
  803.     tmp=ren*ren+imn*imn;
  804.     if(fabs(tmp)<0.00001)tmp=0.00001;
  805.     rereg=(ret*ren+imt*imn)/tmp;
  806.     imreg=(ren*imt-ret*imn)/tmp;
  807.  
  808.     tmp=rereg*rereg-imreg*imreg;
  809.     imreg=2*rereg*imreg;
  810.     rereg=tmp;
  811.  
  812.     absreg=rereg*rereg+imreg*imreg;
  813.  
  814.    if( fabs(absreg) > 10000 )
  815.      { counter&=15;return(); };
  816.    if( (fabs(rereg-1)+fabs(imreg))<0.01 )
  817.      { counter&=15;counter|=16;return(); };
  818.    };
  819.  
  820. }
  821.  
  822.  
  823. void magnet2()
  824. {
  825. register float rereg,imreg,tmpreg,absreg;
  826. float tmp,ret,imt,ren,imn,magr,magi,magr2,magi2;
  827.  
  828. magr=(magre-1)*(magre-2)-magim*magim;
  829. magi=magim*(2*magre-3);
  830. magr2=magre*magre-magim*magim-3*magre+3;
  831. magi2=2*magre*magim-3*magim;
  832. rereg=resave;
  833. imreg=imsave;
  834. for(counter=0;counter<maxiter;counter++)
  835.    {
  836.     ret=rereg*rereg-imreg*imreg+3*(magre-1);
  837.     imt=2*rereg*imreg+3*magim;
  838.     tmp=ret*rereg-imt*imreg+magr;
  839.     imt=ret*imreg+imt*rereg+magi;
  840.     ret=tmp;
  841.     ren=3*(rereg*rereg-imreg*imreg)+3*((magre-2)*rereg-magim*imreg)+magr2;
  842.     imn=6*rereg*imreg+3*(magim*rereg+(magre-2)*imreg)+magi2;
  843.     tmp=ren*ren+imn*imn;
  844.     if(fabs(tmp)<0.00001)tmp=0.00001;
  845.     rereg=(ret*ren+imt*imn)/tmp;
  846.     imreg=(ren*imt-ret*imn)/tmp;
  847.  
  848.     tmp=rereg*rereg-imreg*imreg;
  849.     imreg=2*rereg*imreg;
  850.     rereg=tmp;
  851.  
  852.     absreg=rereg*rereg+imreg*imreg;
  853.  
  854.    if( fabs(absreg) > 10000 )
  855.      { counter&=15;return(); };
  856.    if( (fabs(rereg-1)+fabs(imreg))<0.01 )
  857.      { counter&=15;counter|=16;return(); };
  858.    };
  859.  
  860. }
  861.  
  862.  
  863.  
  864. void magnet3()
  865. {
  866. register float rereg,imreg,tmpreg,absreg;
  867. float tmp,ret,imt,ren,imn,magr,magi,magr2,magi2;
  868.  
  869. magr=(resave-1)*(resave-2)-imsave*imsave;
  870. magi=imsave*(2*resave-3);
  871. magr2=resave*resave-imsave*imsave-3*resave+3;
  872. magi2=2*resave*imsave-3*imsave;
  873. rereg=0;
  874. imreg=0;
  875. for(counter=0;counter<maxiter;counter++)
  876.    {
  877.     ret=rereg*rereg-imreg*imreg+3*(resave-1);
  878.     imt=2*rereg*imreg+3*imsave;
  879.     tmp=ret*rereg-imt*imreg+magr;
  880.     imt=ret*imreg+imt*rereg+magi;
  881.     ret=tmp;
  882.     ren=3*(rereg*rereg-imreg*imreg)+3*((resave-2)*rereg-imsave*imreg)+magr2;
  883.     imn=6*rereg*imreg+3*(imsave*rereg+(resave-2)*imreg)+magi2;
  884.     tmp=ren*ren+imn*imn;
  885.     if(fabs(tmp)<0.00001)tmp=0.00001;
  886.     rereg=(ret*ren+imt*imn)/tmp;
  887.     imreg=(ren*imt-ret*imn)/tmp;
  888.  
  889.     tmp=rereg*rereg-imreg*imreg;
  890.     imreg=2*rereg*imreg;
  891.     rereg=tmp;
  892.  
  893.     absreg=rereg*rereg+imreg*imreg;
  894.  
  895.    if( fabs(absreg) > 10000 )
  896.      { counter&=15;return(); };
  897.    if( (fabs(rereg-1)+fabs(imreg))<0.01 )
  898.      { counter&=15;counter|=16;return(); };
  899.    };
  900.  
  901. }
  902.  
  903.  
  904. void runfractal()
  905. {
  906. rport=wdw->RPort;
  907. SetAPen(rport,0L);
  908. RectFill(rport,0L,0L,(long)(width-1),(long)(height-1));
  909. getvalues();
  910. SetMenuStrip(wdw,(men+3));
  911. switch(surface)
  912.    {
  913.     case D2RECT:
  914.        {
  915.         frac1(fracalg);
  916.         break;
  917.        };
  918.     case D3RECT:
  919.        {
  920.         frac2(fracalg);
  921.         break;
  922.        };
  923.     case SPHERE:
  924.        {
  925.         frac3(fracalg);
  926.         break;
  927.        };
  928.    };
  929. ClearMenuStrip(wdw);
  930. }
  931.  
  932. void frac1(frac)
  933. void (*frac)();
  934. {
  935. float restep2,imstep2;
  936. short colors;
  937.  
  938. colors=(1<<depth)-2;
  939. restep=(remax-remin)/width;
  940. imstep=(immax-immin)/height;
  941. restep2=restep*4;
  942. imstep2=imstep*4;
  943. lambdahalva=lambda/2;
  944. rport=wdw->RPort;
  945.  
  946. for(xoffset=0;xoffset<4;xoffset++)
  947.  {
  948.   for(yoffset=0;yoffset<4;yoffset++)
  949.    {
  950.     resave=remin+restep*xoffset;
  951.     for(xc=xoffset;xc<width;xc+=4)
  952.      {
  953.       resave += restep2;
  954.       imsave=immax-imstep*yoffset;
  955.       for(yc=yoffset;yc<height;yc+=4)
  956.          {
  957.           imsave -= imstep2;
  958.           (*frac)();
  959.           (counter==maxiter)?
  960.               SetAPen(rport,0L):SetAPen(rport,(counter % colors)+2L);
  961.           WritePixel(rport,(long)xc,(long)yc);
  962.           scanmenu();
  963.          };
  964.      };
  965.    };
  966.  };
  967. }
  968.  
  969. void frac2(frac)
  970. void (*frac)();
  971. {
  972. short heighthalf,ycplusheight,xcpluswidth,widthadjuster;
  973. short width2,width3,colors;
  974.  
  975. colors=(1<<depth)-2;
  976. width2=(short)(width*0.875);
  977. width3=width-width2;
  978. heighthalf=height/2;
  979. restep=(remax-remin)/width2*step;
  980. imstep=(immax-immin)/height*step;
  981. lambdahalva=lambda/2;
  982. rport=wdw->RPort;
  983.  
  984. imsave=immax;
  985. for(yc=0;yc<height;yc+=step)
  986.    {
  987.     ycplusheight=yc/2+heighthalf;
  988.     widthadjuster=width3*yc/height;
  989.     imsave -= imstep;
  990.     resave=remin;
  991.     xcpluswidth=widthadjuster;
  992.     for(xc=0;xc<width2;xc+=step)
  993.        {
  994.         resave += restep;
  995.         (*frac)();
  996.         if(counter!=maxiter)
  997.            {
  998.             SetAPen(rport,(long)(counter % colors +2 ));
  999.             counter=(short)(log((double)counter)*heightconst);
  1000.  
  1001.             if(fractal!=BIOMORPH)
  1002.                {
  1003.                 SetAPen(rport,(long)(counter % colors +2 ));
  1004.                };
  1005.  
  1006.             Move(rport,(long)xcpluswidth,(long)(ycplusheight));
  1007.             Draw(rport,(long)xcpluswidth,(long)(ycplusheight-counter));
  1008.            };
  1009.         xcpluswidth+=step;
  1010.         scanmenu();
  1011.       };
  1012.    };
  1013. }
  1014.  
  1015. void frac3(frac)
  1016. void (*frac)();
  1017. {
  1018. short heighthalf,widthhalf;
  1019. short xrad,yrad,colors;
  1020. float xang,yang,angxstep,angystep;
  1021. float xdir,ydir;
  1022. float re1,re2,im1,im2;
  1023.  
  1024. colors=(1<<depth)-2;
  1025. xrad=(width>400)?radius*2:radius;
  1026. yrad=(height>300)?radius*2:radius;
  1027. heighthalf=height/2;
  1028. widthhalf=width/2;
  1029. angxstep=3.1415/widthhalf/2*step;
  1030. angystep=3.1415/heighthalf/2*step;
  1031.  
  1032. restep=(remax-remin)/width*step;
  1033. imstep=(immax-immin)/height*step;
  1034. lambdahalva=lambda/2;
  1035. rport=wdw->RPort;
  1036.  
  1037. yang=3.1415;
  1038. im1=immax;
  1039. im2=immin;
  1040. for(yc=0;yc<heighthalf;yc+=step)
  1041.    {
  1042.     im1 -= imstep;
  1043.     im2 += imstep;
  1044.     yang-=angystep;
  1045.     xang=-3.1415;
  1046.     re1=remin;
  1047.     re2=remax;
  1048.     for(xc=0;xc<widthhalf;xc+=step)
  1049.        {
  1050.         re1 += restep;
  1051.         re2 -= restep;
  1052.         xang+=angxstep;
  1053.         xdir=sin((double)xang)*cos((double)yang);
  1054.         ydir=cos((double)xang);
  1055.         resave=re1;
  1056.         imsave=im1;
  1057.         (*frac)();
  1058.         if(counter!=maxiter)
  1059.            {
  1060.             SetAPen(rport,(long)(counter % colors +2));
  1061.             counter=(short)(log((double)counter)*heightconst);
  1062.             if(fractal!=BIOMORPH)
  1063.                {
  1064.                 SetAPen(rport,(long)(counter % colors +2 ));
  1065.                };
  1066.             Move(rport,(long)(widthhalf +xrad*ydir),
  1067.                        (long)(heighthalf-yrad*xdir));
  1068.             Draw(rport,(long)(widthhalf +ydir*(xrad+counter)),
  1069.                        (long)(heighthalf-xdir*(yrad+counter)));
  1070.            };
  1071.         resave=re2;
  1072.         imsave=im1;
  1073.         (*frac)();
  1074.         if(counter!=maxiter)
  1075.            {
  1076.             SetAPen(rport,(long)(counter % colors +2));
  1077.             counter=(short)(log((double)counter)*heightconst);
  1078.             if(fractal!=BIOMORPH)
  1079.                {
  1080.                 SetAPen(rport,(long)(counter % colors +2 ));
  1081.                };
  1082.             Move(rport,(long)(widthhalf -xrad*ydir),
  1083.                        (long)(heighthalf-yrad*xdir));
  1084.             Draw(rport,(long)(widthhalf -ydir*(xrad+counter)),
  1085.                        (long)(heighthalf-xdir*(yrad+counter)));
  1086.            };
  1087.         resave=re1;
  1088.         imsave=im2;
  1089.         (*frac)();
  1090.         if(counter!=maxiter)
  1091.            {
  1092.             SetAPen(rport,(long)(counter % colors+2));
  1093.             counter=(short)(log((double)counter)*heightconst);
  1094.             if(fractal!=BIOMORPH)
  1095.                {
  1096.                 SetAPen(rport,(long)(counter % colors +2 ));
  1097.                };
  1098.             Move(rport,(long)(widthhalf +xrad*ydir),
  1099.                        (long)(heighthalf+yrad*xdir));
  1100.             Draw(rport,(long)(widthhalf +ydir*(xrad+counter)),
  1101.                        (long)(heighthalf+xdir*(yrad+counter)));
  1102.            };
  1103.         resave=re2;
  1104.         imsave=im2;
  1105.         (*frac)();
  1106.         if(counter!=maxiter)
  1107.            {
  1108.             SetAPen(rport,(long)(counter % colors+2));
  1109.             counter=(short)(log((double)counter)*heightconst);
  1110.             if(fractal!=BIOMORPH)
  1111.                {
  1112.                 SetAPen(rport,(long)(counter % colors +2 ));
  1113.                };
  1114.             Move(rport,(long)(widthhalf -xrad*ydir),
  1115.                        (long)(heighthalf+yrad*xdir));
  1116.             Draw(rport,(long)(widthhalf -ydir*(xrad+counter)),
  1117.                        (long)(heighthalf+xdir*(yrad+counter)));
  1118.            };
  1119.         scanmenu();
  1120.       };
  1121.    };
  1122. }
  1123.  
  1124.  
  1125.  
  1126. void getvalues()
  1127. {
  1128.  
  1129. if(fractal!=ULTIMATE)
  1130.  {
  1131.    gwdw=openwindow(scr,50,10,200,180,(ULONG)ACTIVATE,
  1132.                    (USHORT)(GADGETUP),NULL);
  1133.    rport=gwdw->RPort;
  1134.    SetAPen(rport,1L);
  1135.  
  1136.    PutGadget("ReMin",5,10,20,(gad+0));
  1137.    PutGadget("ReMax",5,110,20,(gad+1));
  1138.    PutGadget("ImMin",5,10,42,(gad+2));
  1139.    PutGadget("ImMax",5,110,42,(gad+3));
  1140.  
  1141.    Move(rport,10L,10L);
  1142.    switch(fractal)
  1143.       {
  1144.        case NEWTON: { Text(rport,"Newton-R",8L);break; };
  1145.        case MANDELBROT: { Text(rport,"Mandelbrot",10L);break; };
  1146.        case BIOMORPH: { Text(rport,"Biomorph",8L);
  1147.                         PutGadget("ReConst",7,10,64,(gad+10));
  1148.                         PutGadget("ImConst",7,110,64,(gad+11));
  1149.                         break; };
  1150.        case JULIA: { Text(rport,"Julia",5L);
  1151.                      PutGadget("ReConst",7,10,64,(gad+7));
  1152.                      PutGadget("ImConst",7,110,64,(gad+8));
  1153.                      break; };
  1154.        case MAGNET2:
  1155.        case MAGNET0:{ Text(rport,"Magnet x",8L);
  1156.                       PutGadget("ReConst",7,10,64,(gad+19));
  1157.                       PutGadget("ImConst",7,110,64,(gad+20));
  1158.                       break; };
  1159.        case MAGNET3:
  1160.        case MAGNET1:{ Text(rport,"Magnet q",8L);break; };
  1161.         case LEXPZ: { Text(rport,"lEXPz",5L);
  1162.                       PutGadget("Lambda",6,10,64,(gad+9));
  1163.                       break; };
  1164.         case LCOSZ: { Text(rport,"lCOSz",5L);
  1165.                       PutGadget("Lambda",6,10,64,(gad+4));
  1166.                       break; };
  1167.         case ESINZ: { Text(rport,"(1-ei)SINz",10L);
  1168.                       PutGadget("Epsilon",7,10,64,(gad+6));
  1169.                       break; };
  1170.        };
  1171.    Move(rport,110L,10L);
  1172.    switch(surface)
  1173.     {
  1174.      case D2RECT: { Text(rport,"2D-Rect",7L);break; };
  1175.      case D3RECT: { Text(rport,"3D-Rect",7L);
  1176.                     PutGadget("HeightConst",11,10,113,(gad+12));
  1177.                     break; };
  1178.      case SPHERE: { Text(rport,"Sphere",6L);
  1179.                     PutGadget("HeightConst",11,10,113,(gad+12));
  1180.                     PutGadget("Radius",6,110,113,(gad+13));
  1181.                     break; };
  1182.     };
  1183.  
  1184.   PutGadget("MaxIter",7,10,135,(gad+5));
  1185.   if(surface!=D2RECT)
  1186.     PutGadget("Step",4,110,135,(gad+14));
  1187.  
  1188.   PutBoolGadget(110,160,(gadb+0));
  1189.  
  1190. Wait(1L << gwdw->UserPort->mp_SigBit);
  1191. while(imsg=(struct IntuiMessage *)GetMsg(gwdw->UserPort))
  1192.       ReplyMsg((struct Message *)imsg);
  1193. CloseWindow(gwdw);
  1194. };
  1195.  
  1196.  
  1197. if(fractal==ULTIMATE)
  1198. {
  1199.   prepult();
  1200. };
  1201.  
  1202.  
  1203. remin=atof(reminbuf);
  1204. remax=atof(remaxbuf);
  1205. immin=atof(imminbuf);
  1206. immax=atof(immaxbuf);
  1207. reconst=atof(reconstbuf);
  1208. imconst=atof(imconstbuf);
  1209. magre=atof(magrebuf);
  1210. magim=atof(magimbuf);
  1211. lambda=atof(lambdabuf);
  1212. lamexp=atof(lamexpbuf);
  1213. epsilon=atof(epsilonbuf);
  1214. bioreconst=atof(biorebuf);
  1215. bioimconst=atof(bioimbuf);
  1216. maxiter=(short)fabs(atof(maxiterbuf));if(maxiter<10)maxiter=10;
  1217. step=(short)fabs(atof(stepbuf));if(step==0)step=1;
  1218. heightconst=atof(hcbuf);
  1219. radius=(short)atof(radiusbuf);
  1220. rulelen=strlen(rulebuf);
  1221. re0const=atof(re0constbuf);
  1222. im0const=atof(im0constbuf);
  1223. re1const=atof(re1constbuf);
  1224. im1const=atof(im1constbuf);
  1225. re2const=atof(re2constbuf);
  1226. im2const=atof(im2constbuf);
  1227. re3const=atof(re3constbuf);
  1228. im3const=atof(im3constbuf);
  1229. re4const=atof(re4constbuf);
  1230. im4const=atof(im4constbuf);
  1231. re5const=atof(re5constbuf);
  1232. im5const=atof(im5constbuf);
  1233. re6const=atof(re6constbuf);
  1234. im6const=atof(im6constbuf);
  1235. re7const=atof(re7constbuf);
  1236. im7const=atof(im7constbuf);
  1237. re8const=atof(re8constbuf);
  1238. im8const=atof(im8constbuf);
  1239. re9const=atof(re9constbuf);
  1240. im9const=atof(im9constbuf);
  1241. Ult_cre[0]=re0const;Ult_cim[0]=im0const;
  1242. Ult_cre[1]=re1const;Ult_cim[1]=im1const;
  1243. Ult_cre[2]=re2const;Ult_cim[2]=im2const;
  1244. Ult_cre[3]=re3const;Ult_cim[3]=im3const;
  1245. Ult_cre[4]=re4const;Ult_cim[4]=im4const;
  1246. Ult_cre[5]=re5const;Ult_cim[5]=im5const;
  1247. Ult_cre[6]=re6const;Ult_cim[6]=im6const;
  1248. Ult_cre[7]=re7const;Ult_cim[7]=im7const;
  1249. Ult_cre[8]=re8const;Ult_cim[8]=im8const;
  1250. Ult_cre[9]=re9const;Ult_cim[9]=im9const;
  1251. lim1=atof(lim1buf);
  1252. lim2=atof(lim2buf);
  1253. lim3=atof(lim3buf);
  1254. lim4=atof(lim4buf);
  1255. }
  1256.  
  1257.  
  1258. void getfractal()
  1259. {
  1260.   { if((itmnum!=BIOTYPE)&&(itmnum!=NEWTONTYPE))fractal=itmnum;
  1261.     switch(itmnum)
  1262.        {
  1263.         case MANDELBROT: { fracalg=mandelbrot;break; };
  1264.         case JULIA: { fracalg=julia;break; };
  1265.         case ULTIMATE:{ fracalg=ultimate;break; };
  1266.         case MAGNET0:{ fracalg=magnet0;break; };
  1267.         case MAGNET1:{ fracalg=magnet1;break; };
  1268.         case MAGNET2:{ fracalg=magnet2;break; };
  1269.         case MAGNET3:{ fracalg=magnet3;break; };
  1270.         case LCOSZ: { fracalg=lcosz;break; };
  1271.         case ESINZ: { fracalg=esinz;break; };
  1272.         case LEXPZ: { fracalg=lexpz;break; };
  1273.         case BIOTYPE: { biomorph=subnum;if(fractal!=BIOMORPH)break; };
  1274.         case BIOMORPH:
  1275.           {
  1276.            switch(biomorph)
  1277.              {
  1278.               case BIO0: { fracalg=bio0;break; };
  1279.               case BIO1: { fracalg=bio1;break; };
  1280.               case BIO2: { fracalg=bio2;break; };
  1281.               case BIO3: { fracalg=bio3;break; };
  1282.               case BIO4: { fracalg=bio4;break; };
  1283.               case BIO5: { fracalg=bio5;break; };
  1284.              };
  1285.            break;
  1286.           };
  1287.         case NEWTONTYPE: { newton=subnum;if(fractal!=NEWTON)break; };
  1288.         case NEWTON:
  1289.           {
  1290.            switch(newton)
  1291.              {
  1292.               case NR0: { fracalg=nr0;break; };
  1293.               case NR1: { fracalg=nr1;break; };
  1294.               case NR2: { fracalg=nr2;break; };
  1295.               case NR3: { fracalg=nr3;break; };
  1296.               case NR4: { fracalg=nr4;break; };
  1297.               case NR5: { fracalg=nr5;break; };
  1298.              };
  1299.            break;
  1300.           };
  1301.        };
  1302.   };
  1303. }
  1304.  
  1305.  
  1306. void prepult()
  1307. {
  1308.    ShowTitle(scr,titelflag=0L);
  1309.    gwdw=openwindow(scr,1,1,318,195,(ULONG)ACTIVATE,
  1310.                    (USHORT)(GADGETUP),NULL);
  1311.    rport=gwdw->RPort;
  1312.    SetAPen(rport,1L);
  1313.    Move(rport,10L,10L);
  1314.    Text(rport,"Ultimate Fractal Generator.",27L);
  1315.  
  1316.    PutGadget("Iteration Rule List",19,10,20,(gad+18));
  1317.    Move(rport,10L,42L);
  1318.    Text(rport,"A  +Z0    K  +Zn    a  +Tx    k  +Cx",36L);
  1319.    Move(rport,10L,51L);
  1320.    Text(rport,"B  -Z0    L  -Zn    b  -Tx    l  -Cx",36L);
  1321.    Move(rport,10L,60L);
  1322.    Text(rport,"C  *Z0    M  *Zn    c  *Tx    m  *Cx",36L);
  1323.    Move(rport,10L,69L);
  1324.    Text(rport,"D  /Z0    N  /Zn    d  /Tx    n  /Cx",36L);
  1325.    Move(rport,10L,78L);
  1326.    Text(rport,"E  ^Z0    O  ^Zn    e  ^Tx    o  ^Cx",36L);
  1327.    Move(rport,10L,87L);
  1328.    Text(rport,"F  ^2     P  ln     f ->Tx          ",36L);
  1329.    Move(rport,10L,96L);
  1330.    Text(rport,"G  ^3     Q  exp    g <-Tx    q  Z >",36L);
  1331.    Move(rport,10L,105L);
  1332.    Text(rport,"H  ^4     R  sin    h <>Tx    r  Re>",36L);
  1333.    Move(rport,10L,114L);
  1334.    Text(rport,"I  ^5     S  cos    i  = 0    s  Im>",36L);
  1335.    Move(rport,10L,123L);
  1336.    Text(rport,"J  ^6     T  tan    j  INV    t  dZ<",36L);
  1337.  
  1338.    PutGadget("ReMin",5,10,143,(gad+0));
  1339.    PutGadget("ReMax",5,110,143,(gad+1));
  1340.    PutGadget("ImMin",5,10,165,(gad+2));
  1341.    PutGadget("ImMax",5,110,165,(gad+3));
  1342.  
  1343.    PutBoolGadget(210,180,(gadb+0));
  1344.  
  1345. Wait(1L << gwdw->UserPort->mp_SigBit);
  1346. while(imsg=(struct IntuiMessage *)GetMsg(gwdw->UserPort))
  1347.       ReplyMsg((struct Message *)imsg);
  1348. CloseWindow(gwdw);
  1349.  
  1350.  
  1351. gwdw=openwindow(scr,1,10,318,180,(ULONG)ACTIVATE,
  1352.                 (USHORT)(GADGETUP),NULL);
  1353. rport=gwdw->RPort;
  1354. SetAPen(rport,1L);
  1355.  
  1356.    PutGadget("ReConst0",8,10,10,(gad+16));
  1357.    PutGadget("ImConst0",8,110,10,(gad+17));
  1358.    PutGadget("ReConst1",8,10,32,(gad+21));
  1359.    PutGadget("ImConst1",8,110,32,(gad+22));
  1360.    PutGadget("ReConst2",8,10,54,(gad+23));
  1361.    PutGadget("ImConst2",8,110,54,(gad+24));
  1362.    PutGadget("ReConst3",8,10,76,(gad+25));
  1363.    PutGadget("ImConst3",8,110,76,(gad+26));
  1364.    PutGadget("ReConst4",8,10,98,(gad+27));
  1365.    PutGadget("ImConst4",8,110,98,(gad+28));
  1366.    PutGadget("ReConst5",8,10,120,(gad+29));
  1367.    PutGadget("ImConst5",8,110,120,(gad+30));
  1368.  
  1369. PutBoolGadget(210,160,(gadb+0));
  1370.  
  1371. Wait(1L << gwdw->UserPort->mp_SigBit);
  1372. while(imsg=(struct IntuiMessage *)GetMsg(gwdw->UserPort))
  1373.       ReplyMsg((struct Message *)imsg);
  1374. CloseWindow(gwdw);
  1375.  
  1376. gwdw=openwindow(scr,1,10,318,180,(ULONG)ACTIVATE,
  1377.                 (USHORT)(GADGETUP),NULL);
  1378. rport=gwdw->RPort;
  1379. SetAPen(rport,1L);
  1380.  
  1381.    PutGadget("ReConst6",8,10,10,(gad+31));
  1382.    PutGadget("ImConst6",8,110,10,(gad+32));
  1383.    PutGadget("ReConst7",8,10,32,(gad+33));
  1384.    PutGadget("ImConst7",8,110,32,(gad+34));
  1385.    PutGadget("ReConst8",8,10,54,(gad+35));
  1386.    PutGadget("ImConst8",8,110,54,(gad+36));
  1387.    PutGadget("ReConst9",8,10,76,(gad+37));
  1388.    PutGadget("ImConst9",8,110,76,(gad+38));
  1389.  
  1390. PutBoolGadget(210,160,(gadb+0));
  1391.  
  1392. Wait(1L << gwdw->UserPort->mp_SigBit);
  1393. while(imsg=(struct IntuiMessage *)GetMsg(gwdw->UserPort))
  1394.       ReplyMsg((struct Message *)imsg);
  1395. CloseWindow(gwdw);
  1396.  
  1397. gwdw=openwindow(scr,1,10,318,180,(ULONG)ACTIVATE,
  1398.                 (USHORT)(GADGETUP),NULL);
  1399. rport=gwdw->RPort;
  1400. SetAPen(rport,1L);
  1401. Move(rport,10L,10L);
  1402. Text(rport,"Ultimate Fractal Generator.",27L);
  1403.  
  1404. PutGadget("Z  >",4,10,20,(gad+39));
  1405. PutGadget("dZ <",4,110,20,(gad+42));
  1406. PutGadget("Re >",4,10,42,(gad+40));
  1407. PutGadget("Im >",4,110,42,(gad+41));
  1408.  
  1409.    Move(rport,240L,10L);
  1410.    switch(surface)
  1411.     {
  1412.      case D2RECT: { Text(rport,"2D-Rect",7L);break; };
  1413.      case D3RECT: { Text(rport,"3D-Rect",7L);
  1414.                     PutGadget("HeightConst",11,10,113,(gad+12));
  1415.                     break; };
  1416.      case SPHERE: { Text(rport,"Sphere",6L);
  1417.                     PutGadget("HeightConst",11,10,113,(gad+12));
  1418.                     PutGadget("Radius",6,110,113,(gad+13));
  1419.                     break; };
  1420.     };
  1421.  
  1422.  
  1423.   PutGadget("MaxIter",7,10,135,(gad+5));
  1424.   if(surface!=D2RECT)
  1425.     PutGadget("Step",4,110,135,(gad+14));
  1426.  
  1427. PutBoolGadget(210,160,(gadb+0));
  1428.  
  1429. Wait(1L << gwdw->UserPort->mp_SigBit);
  1430. while(imsg=(struct IntuiMessage *)GetMsg(gwdw->UserPort))
  1431.       ReplyMsg((struct Message *)imsg);
  1432. CloseWindow(gwdw);
  1433.  
  1434. ShowTitle(scr,titelflag=1L);
  1435. }
  1436.  
  1437.  
  1438. void Ult_A()
  1439. {
  1440. Ult_re+=Ult_Z0re;
  1441. Ult_im+=Ult_Z0im;
  1442. }
  1443.  
  1444. void Ult_B()
  1445. {
  1446. Ult_re-=Ult_Z0re;
  1447. Ult_im-=Ult_Z0im;
  1448. }
  1449.  
  1450. void Ult_C()
  1451. {
  1452. float tmp;
  1453. tmp=Ult_re*Ult_Z0re-Ult_im*Ult_Z0im;
  1454. Ult_im=Ult_im*Ult_Z0re+Ult_re*Ult_Z0im;
  1455. Ult_re=tmp;
  1456. }
  1457.  
  1458. void Ult_D()
  1459. {
  1460. Ult_swplo();
  1461. Ult_re=Ult_Z0re;
  1462. Ult_im=Ult_Z0im;
  1463. Ult_j();
  1464. Ult_mmlo();
  1465. }
  1466.  
  1467. void Ult_E()
  1468. {
  1469. Ult_P();
  1470. Ult_C();
  1471. Ult_Q();
  1472. }
  1473.  
  1474. void Ult_F()
  1475. {
  1476. float tmp;
  1477. tmp=Ult_re*Ult_re-Ult_im*Ult_im;
  1478. Ult_im=2*Ult_re*Ult_im;
  1479. Ult_re=tmp;
  1480. }
  1481.  
  1482. void Ult_G()
  1483. {
  1484. float tmp,tmp2,tmp3;
  1485. tmp2=Ult_re*Ult_re;
  1486. tmp3=Ult_im*Ult_im;
  1487. tmp=Ult_re*(tmp2-3*tmp3);
  1488. Ult_im=Ult_im*(3*tmp2-tmp3);
  1489. Ult_re=tmp;
  1490. }
  1491.  
  1492. void Ult_H()
  1493. {
  1494. Ult_F();
  1495. Ult_F();
  1496. }
  1497.  
  1498. void Ult_I()
  1499. {
  1500. float tmp,tmp2,tmp3,tmp4,tmp5,tmp6;
  1501. tmp2=Ult_re*Ult_re;
  1502. tmp3=Ult_im*Ult_im;
  1503. tmp4=tmp2*tmp2;
  1504. tmp5=tmp2*tmp3;
  1505. tmp6=tmp3*tmp3;
  1506. tmp   =Ult_re*(tmp4-10*tmp5+5*tmp6);
  1507. Ult_im=Ult_im*(5*tmp4-10*tmp5+tmp6);
  1508. Ult_re=tmp;
  1509. }
  1510.  
  1511. void Ult_J()
  1512. {
  1513. float tmp,tmp2,tmp3,tmp4,tmp5,tmp6;
  1514. tmp2=Ult_re*Ult_re;
  1515. tmp3=Ult_im*Ult_im;
  1516. tmp4=tmp2*tmp2;
  1517. tmp5=tmp2*tmp3;
  1518. tmp6=tmp3*tmp3;
  1519. tmp=tmp2*(tmp4+15*(tmp6-tmp5))-tmp6*tmp3;
  1520. Ult_im=Ult_re*Ult_im*(6*(tmp4+tmp6)-20*tmp5);
  1521. Ult_re=tmp;
  1522. }
  1523.  
  1524. void Ult_K()
  1525. {
  1526. Ult_re+=Ult_Znre;
  1527. Ult_im+=Ult_Znim;
  1528. }
  1529.  
  1530. void Ult_L()
  1531. {
  1532. Ult_re-=Ult_Znre;
  1533. Ult_im-=Ult_Znim;
  1534. }
  1535.  
  1536. void Ult_M()
  1537. {
  1538. float tmp;
  1539. tmp=Ult_re*Ult_Znre-Ult_im*Ult_Znim;
  1540. Ult_im=Ult_im*Ult_Znre+Ult_re*Ult_Znim;
  1541. Ult_re=tmp;
  1542. }
  1543.  
  1544. void Ult_N()
  1545. {
  1546. Ult_swplo();
  1547. Ult_re=Ult_Znre;
  1548. Ult_im=Ult_Znim;
  1549. Ult_j();
  1550. Ult_mmlo();
  1551.  
  1552. }
  1553.  
  1554. void Ult_O()
  1555. {
  1556. Ult_P();
  1557. Ult_M();
  1558. Ult_Q();
  1559. }
  1560.  
  1561. void Ult_P()
  1562. {
  1563. float bel,arg,tmp2,tmp3;
  1564.  
  1565. tmp2=Ult_re*Ult_re;
  1566. tmp3=Ult_im*Ult_im;
  1567.  
  1568. bel=sqrt((double)(tmp2+tmp3));
  1569. if(Ult_re>0)arg=atan((double)(Ult_im/Ult_re));
  1570. else if((Ult_re<0)&&(Ult_im>0))arg= 3.1415+atan((double)(Ult_im/Ult_re));
  1571. else if((Ult_re<0)&&(Ult_im<0))arg= -3.1415+atan((double)(Ult_im/Ult_re));
  1572. else if(Ult_im>0)arg=1.5708;
  1573. else arg=-1.5708;
  1574.  
  1575. Ult_re=log((double)bel);
  1576. Ult_im=arg;
  1577. }
  1578.  
  1579. void Ult_Q()
  1580. {
  1581. float tmp;
  1582. tmp=exp((double)Ult_re);
  1583. Ult_re=tmp*cos((double)Ult_im);
  1584. Ult_im=tmp*sin((double)Ult_im);
  1585. }
  1586.  
  1587. void Ult_R()
  1588. {
  1589. float tmp,tmp2,tmp3;
  1590. tmp2=exp(-(double)Ult_im);
  1591. tmp3=exp( (double)Ult_im);
  1592. tmp=0.5*sin((double)Ult_re)*(tmp2+tmp3);
  1593. Ult_im= -0.5*cos((double)Ult_re)*(tmp2-tmp3);
  1594. Ult_re=tmp;
  1595. }
  1596.  
  1597. void Ult_S()
  1598. {
  1599. float tmp,tmp2,tmp3;
  1600. tmp2=exp(-(double)Ult_im);
  1601. tmp3=exp( (double)Ult_im);
  1602. tmp=0.5*cos((double)Ult_re)*(tmp2+tmp3);
  1603. Ult_im=0.5*sin((double)Ult_re)*(tmp2-tmp3);
  1604. Ult_re=tmp;
  1605. }
  1606.  
  1607. void Ult_T()
  1608. {
  1609. Ult_tmpre[10]=Ult_re;Ult_tmpim[10]=Ult_im;
  1610. Ult_S();
  1611. Ult_j();
  1612. Ult_swplo();
  1613. Ult_R();
  1614. Ult_mmlo();
  1615. }
  1616.  
  1617. void Ult_a()
  1618. {
  1619. short pos;
  1620. Ult_cnt++;
  1621. pos=rulebuf[Ult_cnt]-'0';
  1622. Ult_re+=Ult_tmpre[pos];
  1623. Ult_im+=Ult_tmpim[pos];
  1624. }
  1625.  
  1626. void Ult_b()
  1627. {
  1628. short pos;
  1629. Ult_cnt++;
  1630. pos=rulebuf[Ult_cnt]-'0';
  1631. Ult_re-=Ult_tmpre[pos];
  1632. Ult_im-=Ult_tmpim[pos];
  1633. }
  1634.  
  1635. void Ult_c()
  1636. {
  1637. float tmp;
  1638. short pos;
  1639. Ult_cnt++;
  1640. pos=rulebuf[Ult_cnt]-'0';
  1641. tmp=Ult_re*Ult_tmpre[pos]-Ult_im*Ult_tmpim[pos];
  1642. Ult_im=Ult_im*Ult_tmpre[pos]+Ult_re*Ult_tmpim[pos];
  1643. Ult_re=tmp;
  1644. }
  1645.  
  1646. void Ult_d()
  1647. {
  1648. short pos;
  1649. Ult_cnt++;
  1650. pos=rulebuf[Ult_cnt]-'0';
  1651.  
  1652. Ult_swplo();
  1653. Ult_re=Ult_tmpre[pos];
  1654. Ult_im=Ult_tmpim[pos];
  1655. Ult_j();
  1656. Ult_mmlo();
  1657. }
  1658.  
  1659. void Ult_e()
  1660. {
  1661. Ult_P();
  1662. Ult_c();
  1663. Ult_Q();
  1664. }
  1665.  
  1666. void Ult_f()
  1667. {
  1668. short pos;
  1669. Ult_cnt++;
  1670. pos=rulebuf[Ult_cnt]-'0';
  1671. Ult_tmpre[pos]=Ult_re;
  1672. Ult_tmpim[pos]=Ult_im;
  1673. }
  1674.  
  1675. void Ult_g()
  1676. {
  1677. short pos;
  1678. Ult_cnt++;
  1679. pos=rulebuf[Ult_cnt]-'0';
  1680. Ult_re=Ult_tmpre[pos];
  1681. Ult_im=Ult_tmpim[pos];
  1682. }
  1683.  
  1684. void Ult_h()
  1685. {
  1686. short pos;
  1687. float tmp;
  1688. Ult_cnt++;
  1689. pos=rulebuf[Ult_cnt]-'0';
  1690. tmp=Ult_re;
  1691. Ult_re=Ult_tmpre[pos];
  1692. Ult_tmpre[pos]=tmp;
  1693. tmp=Ult_im;
  1694. Ult_im=Ult_tmpim[pos];
  1695. Ult_tmpim[pos]=tmp;
  1696. }
  1697.  
  1698. void Ult_i()
  1699. {
  1700. Ult_re=Ult_im=0;
  1701. }
  1702.  
  1703. void Ult_j()
  1704. {
  1705. float tmp;
  1706. tmp=Ult_re*Ult_re+Ult_im*Ult_im;
  1707. if( fabs((double)tmp)<0.0000000000001 )tmp=0.0000000000001;
  1708. Ult_re/=tmp;
  1709. Ult_im= -Ult_im/tmp;
  1710. }
  1711.  
  1712. void Ult_k()
  1713. {
  1714. short pos;
  1715. Ult_cnt++;
  1716. pos=rulebuf[Ult_cnt]-'0';
  1717. Ult_re+=Ult_cre[pos];
  1718. Ult_im+=Ult_cim[pos];
  1719. }
  1720.  
  1721. void Ult_l()
  1722. {
  1723. short pos;
  1724. Ult_cnt++;
  1725. pos=rulebuf[pos]-'0';
  1726. Ult_re-=Ult_cre[pos];
  1727. Ult_im-=Ult_cim[pos];
  1728. }
  1729.  
  1730. void Ult_m()
  1731. {
  1732. float tmp;
  1733. short pos;
  1734. Ult_cnt++;
  1735. pos=rulebuf[Ult_cnt]-'0';
  1736. tmp=Ult_re*Ult_cre[pos]-Ult_im*Ult_cim[pos];
  1737. Ult_im=Ult_im*Ult_cre[pos]+Ult_re*Ult_cim[pos];
  1738. Ult_re=tmp;
  1739. }
  1740.  
  1741. void Ult_n()
  1742. {
  1743. short pos;
  1744. Ult_cnt++;
  1745. pos=rulebuf[Ult_cnt]-'0';
  1746.  
  1747. Ult_swplo();
  1748. Ult_re=Ult_cre[pos];
  1749. Ult_im=Ult_cim[pos];
  1750. Ult_j();
  1751. Ult_mmlo();
  1752. }
  1753.  
  1754. void Ult_o()
  1755. {
  1756. Ult_P();
  1757. Ult_m();
  1758. Ult_Q();
  1759. }
  1760.  
  1761. void Ult_p()
  1762. {
  1763. }
  1764.  
  1765. void Ult_q()
  1766. {
  1767. if( (Ult_re*Ult_re+Ult_im*Ult_im)>(Ult_Zmax*Ult_Zmax) )Ult_brk=1;
  1768. }
  1769.  
  1770. void Ult_r()
  1771. {
  1772. if( (fabs((double)Ult_re)>Ult_Zremax) ){ Ult_brk=1;counter++;};
  1773. }
  1774.  
  1775. void Ult_s()
  1776. {
  1777. if( (fabs((double)Ult_im)>Ult_Zimmax) ){ Ult_brk=1;counter+=2;};
  1778. }
  1779.  
  1780. void Ult_t()
  1781. {
  1782. if( (fabs((double)(Ult_re-Ult_Znre))+fabs((double)(Ult_im-Ult_Znim)))<Ult_dZmin )Ult_brk=1;
  1783. }
  1784.  
  1785. void Ult_swplo()
  1786. {
  1787. float tmp;
  1788. tmp=Ult_re;Ult_re=Ult_tmpre[10];Ult_tmpre[10]=tmp;
  1789. tmp=Ult_im;Ult_im=Ult_tmpim[10];Ult_tmpim[10]=tmp;
  1790. }
  1791.  
  1792. void Ult_swphi()
  1793. {
  1794. float tmp;
  1795. tmp=Ult_re;Ult_re=Ult_tmpre[11];Ult_tmpre[11]=tmp;
  1796. tmp=Ult_im;Ult_im=Ult_tmpim[11];Ult_tmpim[11]=tmp;
  1797. }
  1798.  
  1799. void Ult_mmlo()
  1800. {
  1801. float tmp;
  1802. tmp   =Ult_re*Ult_tmpre[10]-Ult_im*Ult_tmpim[10];
  1803. Ult_im=Ult_re*Ult_tmpim[10]+Ult_im*Ult_tmpre[10];
  1804. Ult_re=tmp;
  1805. }
  1806.  
  1807. void Ult_plo()
  1808. {
  1809. Ult_re+=Ult_tmpre[10];
  1810. Ult_im+=Ult_tmpim[10];
  1811. }
  1812.  
  1813. void ultimate()
  1814. {
  1815. char rule;
  1816.  
  1817. Ult_re=0;
  1818. Ult_im=0;
  1819. Ult_Znre=Ult_Z0re=resave;
  1820. Ult_Znim=Ult_Z0im=imsave;
  1821. Ult_brk=0;
  1822. Ult_cnt=0;
  1823. rule=rulebuf[Ult_cnt];
  1824.  
  1825. for(counter=0;counter<10;counter++)
  1826.    {
  1827.     Ult_tmpre[counter]=Ult_tmpim[counter]=0;
  1828.    };
  1829.  
  1830. for(counter=0;counter<maxiter;)
  1831.    {
  1832.  
  1833.    if( rule < 'K' )
  1834.      {
  1835.       switch(rule)
  1836.         {
  1837.          case 'A':{Ult_A();break;};
  1838.          case 'B':{Ult_B();break;};
  1839.          case 'C':{Ult_C();break;};
  1840.          case 'D':{Ult_D();break;};
  1841.          case 'E':{Ult_E();break;};
  1842.          case 'F':{Ult_F();break;};
  1843.          case 'G':{Ult_G();break;};
  1844.          case 'H':{Ult_H();break;};
  1845.          case 'I':{Ult_I();break;};
  1846.          case 'J':{Ult_J();break;};
  1847.         };
  1848.      }
  1849.    else
  1850.    if( rule < 'a' )
  1851.      {
  1852.       switch(rule)
  1853.         {
  1854.          case 'K':{Ult_K();break;};
  1855.          case 'L':{Ult_L();break;};
  1856.          case 'M':{Ult_M();break;};
  1857.          case 'N':{Ult_N();break;};
  1858.          case 'O':{Ult_O();break;};
  1859.          case 'P':{Ult_P();break;};
  1860.          case 'Q':{Ult_Q();break;};
  1861.          case 'R':{Ult_R();break;};
  1862.          case 'S':{Ult_S();break;};
  1863.          case 'T':{Ult_T();break;};
  1864.         };
  1865.      }
  1866.    else
  1867.    if( rule < 'k' )
  1868.      {
  1869.       switch(rule)
  1870.         {
  1871.          case 'a':{Ult_a();break;};
  1872.          case 'b':{Ult_b();break;};
  1873.          case 'c':{Ult_c();break;};
  1874.          case 'd':{Ult_d();break;};
  1875.          case 'e':{Ult_e();break;};
  1876.          case 'f':{Ult_f();break;};
  1877.          case 'g':{Ult_g();break;};
  1878.          case 'h':{Ult_R();break;};
  1879.          case 'i':{Ult_i();break;};
  1880.          case 'j':{Ult_j();break;};
  1881.         };
  1882.      }
  1883.    else
  1884.    if( rule < 'u' )
  1885.      {
  1886.       switch(rule)
  1887.         {
  1888.          case 'k':{Ult_k();break;};
  1889.          case 'l':{Ult_l();break;};
  1890.          case 'm':{Ult_m();break;};
  1891.          case 'n':{Ult_n();break;};
  1892.          case 'o':{Ult_o();break;};
  1893.          case 'p':{Ult_p();break;};
  1894.          case 'q':{Ult_q();break;};
  1895.          case 'r':{Ult_r();break;};
  1896.          case 's':{Ult_s();break;};
  1897.          case 't':{Ult_t();break;};
  1898.         };
  1899.      };
  1900.  
  1901.     if(++Ult_cnt >= rulelen)
  1902.       {
  1903.        if(Ult_brk!=0)return();
  1904.        Ult_cnt=0;
  1905.        counter++;    /* RuleCykle finished , one iteration complete */
  1906.        Ult_Znre=Ult_re;
  1907.        Ult_Znim=Ult_im;
  1908.        Ult_re=Ult_im=0;
  1909.       };
  1910.    rule=rulebuf[Ult_cnt];
  1911.  
  1912.    };
  1913.  
  1914. }
  1915.  
  1916.